package collection

import (
	"encoding/binary"
	"fmt"
	"hash/fnv"
	"iter"
	"strings"
	"sync"
	"time"

	"gitee.com/gousing/helper/hasher"
	"gitee.com/gousing/helper/jsoner"
	"gitee.com/gousing/values"
)

// NewMapAnySync MapAny分段锁数据结构(并发安全)
//   - numShards 分段锁数量，默认128段
//   - 适用于读多写少占比场景，请调整分段数, 建议128或以上
//   - 适用于读少写多均衡场景，请提高分段数，建议128或以下
//   - 适用于读写均衡场景，请提高分段数，建议128
func NewMapAnySync[K comparable](numShards ...uint32) *MapAnySync[K] {
	var numShard uint32 = 128
	if len(numShards) > 0 && numShards[0] > 0 {
		numShard = numShards[0]
	}
	m := MapAnySync[K]{shards: make([]*mapSyncShard[K], numShard), numShard: numShard}
	var i uint32
	for i = 0; i < numShard; i++ {
		m.shards[i] = &mapSyncShard[K]{
			data: make(map[K]any, 0),
			mu:   sync.RWMutex{},
		}
	}
	return &m
}

type MapAnySync[K comparable] struct {
	shards   []*mapSyncShard[K]
	numShard uint32
}
type mapSyncShard[K comparable] struct {
	data map[K]any
	mu   sync.RWMutex
}

// shardSync 计算散列值时，key 使用泛型类型，避免编译器优化(类型推断)
func (m *MapAnySync[K]) shardSync(key K) *mapSyncShard[K] {
	if m.numShard == 1 {
		return m.shards[0]
	}
	// shardSync 计算散列值时，key 使用泛型类型，避免编译器优化(类型推断)
	var keyAny any = key

	if keyAny == nil {
		return m.shards[hashFnvOffset32%m.numShard]
	}
	switch keyVal := keyAny.(type) {
	case string:
		hash := hashFnvOffset32
		for i := 0; i < len(keyVal); i++ {
			hash ^= uint32(keyVal[i])
			hash *= hashFnvPrime32
		}
		return m.shards[hash%m.numShard]
	case int:
		h := fnv.New32a()
		if is64Bit {
			k64 := int64(keyVal)
			binary.Write(h, binary.BigEndian, &k64)
		} else {
			k32 := int32(keyVal)
			binary.Write(h, binary.BigEndian, &k32)
		}
		return m.shards[h.Sum32()%m.numShard]
	case int8:
		h := fnv.New32a()
		binary.Write(h, binary.BigEndian, &keyVal)
		return m.shards[h.Sum32()%m.numShard]
	case int16:
		h := fnv.New32a()
		binary.Write(h, binary.BigEndian, &keyVal)
		return m.shards[h.Sum32()%m.numShard]
	case int32:
		h := fnv.New32a()
		binary.Write(h, binary.BigEndian, &keyVal)
		return m.shards[h.Sum32()%m.numShard]
	case int64:
		h := fnv.New32a()
		binary.Write(h, binary.BigEndian, &keyVal)
		return m.shards[h.Sum32()%m.numShard]
	case uint:
		h := fnv.New32a()
		if is64Bit {
			u64 := uint64(keyVal)
			_, _ = h.Write([]byte{byte(u64 >> 56), byte(u64 >> 48), byte(u64 >> 40), byte(u64 >> 32), byte(u64 >> 24), byte(u64 >> 16), byte(u64 >> 8), byte(u64)})
		} else {
			u32 := uint32(keyVal)
			_, _ = h.Write([]byte{byte(u32 >> 24), byte(u32 >> 16), byte(u32 >> 8), byte(u32)})
		}
		return m.shards[h.Sum32()%m.numShard]
	case uint8:
		h := fnv.New32a()
		_, _ = h.Write([]byte{byte(keyVal)})
		return m.shards[h.Sum32()%m.numShard]
	case uint16:
		h := fnv.New32a()
		_, _ = h.Write([]byte{byte(keyVal >> 8), byte(keyVal)})
		return m.shards[h.Sum32()%m.numShard]
	case uint32:
		h := fnv.New32a()
		_, _ = h.Write([]byte{byte(keyVal >> 24), byte(keyVal >> 16), byte(keyVal >> 8), byte(keyVal)})
		return m.shards[h.Sum32()%m.numShard]
	case uint64:
		h := fnv.New32a()
		_, _ = h.Write([]byte{byte(keyVal >> 56), byte(keyVal >> 48), byte(keyVal >> 40), byte(keyVal >> 32), byte(keyVal >> 24), byte(keyVal >> 16), byte(keyVal >> 8), byte(keyVal)})
		return m.shards[h.Sum32()%m.numShard]
	case float32:
		h := fnv.New32a()
		binary.Write(h, binary.BigEndian, &keyVal)
		return m.shards[h.Sum32()%m.numShard]
	case float64:
		h := fnv.New32a()
		binary.Write(h, binary.BigEndian, &keyVal)
		return m.shards[h.Sum32()%m.numShard]
	case time.Time:
		if keyVal.IsZero() {
			return m.shards[hashFnvOffset32%m.numShard]
		}
		h := fnv.New32a()
		k64 := keyVal.UnixNano()
		binary.Write(h, binary.BigEndian, &k64)
		return m.shards[h.Sum32()%m.numShard]
	case time.Duration:
		if keyVal == 0 {
			return m.shards[hashFnvOffset32%m.numShard]
		}
		h := fnv.New32a()
		k64 := keyVal.Nanoseconds()
		binary.Write(h, binary.BigEndian, &k64)
		return m.shards[h.Sum32()%m.numShard]
	case bool:
		// Key 为 bool 类型时，分片数固定为1，不会进行此运算
		if keyVal {
			return m.shards[1%m.numShard]
		} else {
			return m.shards[0%m.numShard]
		}
	case complex64:
		if keyVal == 0 {
			return m.shards[hashFnvOffset32%m.numShard]
		}
		h := fnv.New32a()
		binary.Write(h, binary.LittleEndian, real(keyVal))
		binary.Write(h, binary.LittleEndian, imag(keyVal))
		return m.shards[h.Sum32()%m.numShard]
	case complex128:
		if keyVal == 0 {
			return m.shards[hashFnvOffset32%m.numShard]
		}
		h := fnv.New32a()
		binary.Write(h, binary.LittleEndian, real(keyVal))
		binary.Write(h, binary.LittleEndian, imag(keyVal))
		return m.shards[h.Sum32()%m.numShard]
	default:
		return m.shards[hasher.Fnv32Any(key)%m.numShard]
	}
}

// Set 添加键值，单层替换方式
func (m *MapAnySync[K]) Set(key K, val any) *MapAnySync[K] {
	m.shardSync(key).set(key, val)
	return m
}

// Merge 合并map到*MapShard, 单层替换方式合并
func (m *MapAnySync[K]) Merge(maps map[K]any) *MapAnySync[K] {
	if len(maps) == 0 {
		return m
	}
	for key, val := range maps {
		m.shardSync(key).set(key, val)
	}
	return m
}

// Has 判断键值是否存在
func (m *MapAnySync[K]) Has(key K) bool {
	return m.shardSync(key).has(key)
}

// GetE 获取键值
func (m *MapAnySync[K]) GetE(key K) (any, bool) {
	return m.shardSync(key).get(key)
}

// GetOrSet 获取键值，不存在则设置
//   - 如果key不存在，则设置 k => val 并返回 val,false
//   - 如果key存在，则读取 k => val, 返回 val,true
func (m *MapAnySync[K]) GetOrSet(key K, val any) (actual any, loaded bool) {
	if v, loaded := m.shardSync(key).get(key); loaded {
		return v, loaded
	}
	m.shardSync(key).set(key, val)
	return val, false
}

// GetAndDelete 获取键值，如键值存在则同时删除
//   - 如果key存在，则读取 key => value 后删除 key, 返回 value,true
//   - 如果key不存在，则返回 nil,false
func (m *MapAnySync[K]) GetAndDelete(key K) (value any, loaded bool) {
	if v, loaded := m.shardSync(key).get(key); loaded {
		m.shardSync(key).delete(key)
		return v, loaded
	}
	return nil, false
}

// Delete 删除键值
func (m *MapAnySync[K]) Delete(key K) *MapAnySync[K] {
	m.shardSync(key).delete(key)
	return m
}

// Int 获取Int类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Int(key K) int {
	return m.IntD(key, 0)
}

// IntD 获取Int类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) IntD(key K, defaultVal int) int {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToIntE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// IntE 获取Int类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) IntE(key K) (int, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToIntE(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint 获取Uint类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Uint(key K) uint {
	return m.UintD(key, 0)
}

// UintD 获取Uint类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) UintD(key K, defaultVal uint) uint {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToUintE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// UintE 获取Uint类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) UintE(key K) (uint, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToUintE(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Int8 获取Int8类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Int8(key K) int8 {
	return m.Int8D(key, 0)
}

// Int8D 获取Int8类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Int8D(key K, defaultVal int8) int8 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToInt8E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Int8E 获取Int8类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Int8E(key K) (int8, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToInt8E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int8")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint8 获取Uint8类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Uint8(key K) uint8 {
	return m.Uint8D(key, 0)
}

// Uint8D 获取Uint8类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Uint8D(key K, defaultVal uint8) uint8 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToUint8E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Uint8E 获取Uint8类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Uint8E(key K) (uint8, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToUint8E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint8")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Int16 获取Int16类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Int16(key K) int16 {
	return m.Int16D(key, 0)
}

// Int16D 获取Int16类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Int16D(key K, defaultVal int16) int16 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToInt16E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Int16E 获取Int16类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Int16E(key K) (int16, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToInt16E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int16")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint16 获取Uint16类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Uint16(key K) uint16 {
	return m.Uint16D(key, 0)
}

// Uint16D 获取Uint16类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Uint16D(key K, defaultVal uint16) uint16 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToUint16E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Uint16E 获取Uint16类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Uint16E(key K) (uint16, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToUint16E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint16")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Int32 获取Int32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Int32(key K) int32 {
	return m.Int32D(key, 0)
}

// Int32D 获取Int32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Int32D(key K, defaultVal int32) int32 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToInt32E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Int32E 获取Int32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Int32E(key K) (int32, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToInt32E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int32")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint32 获取Uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Uint32(key K) uint32 {
	return m.Uint32D(key, 0)
}

// Uint32D 获取Uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Uint32D(key K, defaultVal uint32) uint32 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToUint32E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Uint32E 获取Uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Uint32E(key K) (uint32, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToUint32E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint32")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Int64 获取Int64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Int64(key K) int64 {
	return m.Int64D(key, 0)
}

// Int64D 获取Int64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Int64D(key K, defaultVal int64) int64 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToInt64E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Int64E 获取Int64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Int64E(key K) (int64, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToInt64E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "int64")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Uint64 获取Uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Uint64(key K) uint64 {
	return m.Uint64D(key, 0)
}

// Uint64D 获取Uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Uint64D(key K, defaultVal uint64) uint64 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToUint64E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Uint64E 获取Uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Uint64E(key K) (uint64, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToUint64E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "uint64")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Float32 获取Float32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Float32(key K) float32 {
	return m.Float32D(key, 0)
}

// Float32D 获取Float32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Float32D(key K, defaultVal float32) float32 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToFloat32E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Float32E 获取Float32类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Float32E(key K) (float32, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToFloat32E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "float32")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// Float64 获取Float64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Float64(key K) float64 {
	return m.Float64D(key, 0)
}

// Float64D 获取Float64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) Float64D(key K, defaultVal float64) float64 {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToFloat64E(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// Float64E 获取Float64类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) Float64E(key K) (float64, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToFloat64E(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "float64")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// String 获取String类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) String(key K) string {
	return m.StringD(key, "")
}

// StringD 获取String类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) StringD(key K, defaultVal string) string {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToStringE(v); err == nil {
			return strings.TrimSpace(val)
		}
	}
	return defaultVal
}

// StringE 获取String类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) StringE(key K) (string, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToStringE(v)
		if err == nil {
			return val, nil
		}
		return "", errMapValToType(key, v, "string")
	}
	return "", errMapKeyDoesNotExist(key)
}

// Bool 获取Bool类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) Bool(key K) bool {
	return m.BoolD(key, false)
}

// BoolD 获取Bool类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) BoolD(key K, defaultVal bool) bool {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToBoolE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// BoolE 获取Bool类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) BoolE(key K) (bool, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToBoolE(v)
		if err == nil {
			return val, nil
		}
		return false, errMapValToType(key, v, "bool")
	}
	return false, errMapKeyDoesNotExist(key)
}

// Time 获取time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
//   - 如待转换目标是日期时间字符串未包含时区信息时则使用UTC时区
func (m *MapAnySync[K]) Time(key K) time.Time {
	return m.TimeD(key, time.Time{})
}

// TimeD 获取time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
//   - 如待转换目标是日期时间字符串未包含时区信息时则使用UTC时区
func (m *MapAnySync[K]) TimeD(key K, defaultVal time.Time) time.Time {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToTimeE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// TimeE 获取time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
//   - 如待转换目标是日期时间字符串未包含时区信息时则使用UTC时区
func (m *MapAnySync[K]) TimeE(key K) (time.Time, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToTimeE(v)
		if err == nil {
			return val, nil
		}
		return time.Time{}, errMapValToType(key, v, "time.Time")
	}
	return time.Time{}, errMapKeyDoesNotExist(key)
}

// TimeWith 获取time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
//   - 如待转换目标是日期时间字符串未包含时区信息时则使用location指定的时区
func (m *MapAnySync[K]) TimeWith(key K, location *time.Location) (time.Time, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToTimeWith(v, location)
		if err == nil {
			return val, nil
		}
		return time.Time{}, errMapValToType(key, v, "time.Time")
	}
	return time.Time{}, errMapKeyDoesNotExist(key)
}

// TimeDuration 获取time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回零值
func (m *MapAnySync[K]) TimeDuration(key K) time.Duration {
	return m.TimeDurationD(key, 0)
}

// TimeDurationD 获取time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) TimeDurationD(key K, defaultVal time.Duration) time.Duration {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToTimeDurationE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// TimeDurationE 获取time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回零值和错误提示
func (m *MapAnySync[K]) TimeDurationE(key K) (time.Duration, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToTimeDurationE(v)
		if err == nil {
			return val, nil
		}
		return 0, errMapValToType(key, v, "bool")
	}
	return 0, errMapKeyDoesNotExist(key)
}

// SliceAny 获取[]any类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (m *MapAnySync[K]) SliceAny(key K) []any {
	return m.SliceAnyD(key, []any{})
}

// SliceAnyD 获取[]any类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (m *MapAnySync[K]) SliceAnyD(key K, defaultVal []any) []any {
	if v, ok := m.shardSync(key).get(key); ok {
		if val, err := values.ToSliceAnyE(v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceAnyE 获取[]any类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (m *MapAnySync[K]) SliceAnyE(key K) ([]any, error) {
	if v, ok := m.shardSync(key).get(key); ok {
		val, err := values.ToSliceAnyE(v)
		if err == nil {
			return val, nil
		}
		return []any{}, errMapValToType(key, v, "[]any")
	}
	return []any{}, errMapKeyDoesNotExist(key)
}

// SliceString 获取[]string类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceString(name K) []string {
	return s.SliceStringD(name, []string{})
}

// SliceStringD 获取[]string类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceStringD(name K, defaultVal []string) []string {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[string](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceStringE 获取[]string类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceStringE(name K) ([]string, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[string](v)
		if err == nil {
			return val, nil
		}
		return []string{}, errMapValToType(name, v, "[]string")
	}
	return []string{}, errMapKeyDoesNotExist(name)
}

// SliceBool 获取[]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceBool(name K) []bool {
	return s.SliceBoolD(name, []bool{})
}

// SliceBoolD 获取[]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceBoolD(name K, defaultVal []bool) []bool {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[bool](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceBoolE 获取[]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceBoolE(name K) ([]bool, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[bool](v)
		if err == nil {
			return val, nil
		}
		return []bool{}, errMapValToType(name, v, "[]bool")
	}
	return []bool{}, errMapKeyDoesNotExist(name)
}

// SliceInt 获取[]int类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceInt(name K) []int {
	return s.SliceIntD(name, []int{})
}

// SliceIntD 获取[]int类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceIntD(name K, defaultVal []int) []int {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[int](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceIntE 获取[]int类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceIntE(name K) ([]int, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[int](v)
		if err == nil {
			return val, nil
		}
		return []int{}, errMapValToType(name, v, "[]int")
	}
	return []int{}, errMapKeyDoesNotExist(name)
}

// SliceUint 获取[]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceUint(name K) []uint {
	return s.SliceUintD(name, []uint{})
}

// SliceUintD 获取[]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceUintD(name K, defaultVal []uint) []uint {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[uint](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceUintE 获取[]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceUintE(name K) ([]uint, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[uint](v)
		if err == nil {
			return val, nil
		}
		return []uint{}, errMapValToType(name, v, "[]uint")
	}
	return []uint{}, errMapKeyDoesNotExist(name)
}

// SliceInt32 获取[]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceInt32(name K) []int32 {
	return s.SliceInt32D(name, []int32{})
}

// SliceInt32D 获取[]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceInt32D(name K, defaultVal []int32) []int32 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[int32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceInt32E 获取[]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceInt32E(name K) ([]int32, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[int32](v)
		if err == nil {
			return val, nil
		}
		return []int32{}, errMapValToType(name, v, "[]int32")
	}
	return []int32{}, errMapKeyDoesNotExist(name)
}

// SliceUint32 获取[]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceUint32(name K) []uint32 {
	return s.SliceUint32D(name, []uint32{})
}

// SliceUint32D 获取[]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceUint32D(name K, defaultVal []uint32) []uint32 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[uint32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceUint32E 获取[]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceUint32E(name K) ([]uint32, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[uint32](v)
		if err == nil {
			return val, nil
		}
		return []uint32{}, errMapValToType(name, v, "[]uint32")
	}
	return []uint32{}, errMapKeyDoesNotExist(name)
}

// SliceInt64 获取[]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceInt64(name K) []int64 {
	return s.SliceInt64D(name, []int64{})
}

// SliceInt64D 获取[]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceInt64D(name K, defaultVal []int64) []int64 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[int64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceInt64E 获取[]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceInt64E(name K) ([]int64, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[int64](v)
		if err == nil {
			return val, nil
		}
		return []int64{}, errMapValToType(name, v, "[]int64")
	}
	return []int64{}, errMapKeyDoesNotExist(name)
}

// SliceUint64 获取[]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceUint64(name K) []uint64 {
	return s.SliceUint64D(name, []uint64{})
}

// SliceUint64D 获取[]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceUint64D(name K, defaultVal []uint64) []uint64 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[uint64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceUint64E 获取[]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceUint64E(name K) ([]uint64, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[uint64](v)
		if err == nil {
			return val, nil
		}
		return []uint64{}, errMapValToType(name, v, "[]uint64")
	}
	return []uint64{}, errMapKeyDoesNotExist(name)
}

// SliceFloat32 获取[]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceFloat32(name K) []float32 {
	return s.SliceFloat32D(name, []float32{})
}

// SliceFloat32D 获取[]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceFloat32D(name K, defaultVal []float32) []float32 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[float32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceFloat32E 获取[]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceFloat32E(name K) ([]float32, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[float32](v)
		if err == nil {
			return val, nil
		}
		return []float32{}, errMapValToType(name, v, "[]float32")
	}
	return []float32{}, errMapKeyDoesNotExist(name)
}

// SliceFloat64 获取[]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceFloat64(name K) []float64 {
	return s.SliceFloat64D(name, []float64{})
}

// SliceFloat64D 获取[]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceFloat64D(name K, defaultVal []float64) []float64 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[float64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceFloat64E 获取[]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceFloat64E(name K) ([]float64, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[float64](v)
		if err == nil {
			return val, nil
		}
		return []float64{}, errMapValToType(name, v, "[]float64")
	}
	return []float64{}, errMapKeyDoesNotExist(name)
}

// SliceTime 获取[]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceTime(name K) []time.Time {
	return s.SliceTimeD(name, []time.Time{})
}

// SliceTimeD 获取[]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceTimeD(name K, defaultVal []time.Time) []time.Time {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[time.Time](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceTimeE 获取[]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceTimeE(name K) ([]time.Time, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[time.Time](v)
		if err == nil {
			return val, nil
		}
		return []time.Time{}, errMapValToType(name, v, "[]time.Time")
	}
	return []time.Time{}, errMapKeyDoesNotExist(name)
}

// SliceTimeDuration 获取[]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片
func (s *MapAnySync[K]) SliceTimeDuration(name K) []time.Duration {
	return s.SliceTimeDurationD(name, []time.Duration{})
}

// SliceTimeDurationD 获取[]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) SliceTimeDurationD(name K, defaultVal []time.Duration) []time.Duration {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToSliceAsE[time.Duration](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// SliceTimeDurationE 获取[]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回空切片和错误信息
func (s *MapAnySync[K]) SliceTimeDurationE(name K) ([]time.Duration, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToSliceAsE[time.Duration](v)
		if err == nil {
			return val, nil
		}
		return []time.Duration{}, errMapValToType(name, v, "[]time.Duration")
	}
	return []time.Duration{}, errMapKeyDoesNotExist(name)
}

// MapAny 获取map[string]any类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapAny(name K) map[string]any {
	return s.MapAnyD(name, map[string]any{})
}

// MapAnyD 获取map[string]any类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapAnyD(name K, defaultVal map[string]any) map[string]any {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAnyE[string](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapAnyE 获取map[string]any类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapAnyE(name K) (map[string]any, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAnyE[string](v)
		if err == nil {
			return val, nil
		}
		return map[string]any{}, errMapValToType(name, v, "map[string]any")
	}
	return map[string]any{}, errMapKeyDoesNotExist(name)
}

// MapString 获取map[string]string类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapString(name K) map[string]string {
	return s.MapStringD(name, map[string]string{})
}

// MapStringD 获取map[string]string类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapStringD(name K, defaultVal map[string]string) map[string]string {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, string](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapStringE 获取map[string]string类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapStringE(name K) (map[string]string, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, string](v)
		if err == nil {
			return val, nil
		}
		return map[string]string{}, errMapValToType(name, v, "map[string]string")
	}
	return map[string]string{}, errMapKeyDoesNotExist(name)
}

// MapBool 获取map[string]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapBool(name K) map[string]bool {
	return s.MapBoolgD(name, map[string]bool{})
}

// MapBoolgD 获取map[string]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapBoolgD(name K, defaultVal map[string]bool) map[string]bool {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, bool](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapBoolE 获取map[string]bool类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapBoolE(name K) (map[string]bool, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, bool](v)
		if err == nil {
			return val, nil
		}
		return map[string]bool{}, errMapValToType(name, v, "map[string]bool")
	}
	return map[string]bool{}, errMapKeyDoesNotExist(name)
}

// MapInt 获取map[string]int类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapInt(name K) map[string]int {
	return s.MapIntD(name, map[string]int{})
}

// MapIntD 获取map[string]int类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapIntD(name K, defaultVal map[string]int) map[string]int {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, int](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapIntE 获取map[string]int类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapIntE(name K) (map[string]int, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, int](v)
		if err == nil {
			return val, nil
		}
		return map[string]int{}, errMapValToType(name, v, "map[string]int")
	}
	return map[string]int{}, errMapKeyDoesNotExist(name)
}

// MapUint 获取map[string]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapUint(name K) map[string]uint {
	return s.MapUintD(name, map[string]uint{})
}

// MapUintD 获取map[string]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapUintD(name K, defaultVal map[string]uint) map[string]uint {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, uint](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapUintE 获取map[string]uint类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapUintE(name K) (map[string]uint, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, uint](v)
		if err == nil {
			return val, nil
		}
		return map[string]uint{}, errMapValToType(name, v, "map[string]uint")
	}
	return map[string]uint{}, errMapKeyDoesNotExist(name)
}

// MapInt32 获取map[string]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapInt32(name K) map[string]int32 {
	return s.MapInt32D(name, map[string]int32{})
}

// MapInt32D 获取map[string]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapInt32D(name K, defaultVal map[string]int32) map[string]int32 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, int32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapInt32E 获取map[string]int32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapInt32E(name K) (map[string]int32, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, int32](v)
		if err == nil {
			return val, nil
		}
		return map[string]int32{}, errMapValToType(name, v, "map[string]int32")
	}
	return map[string]int32{}, errMapKeyDoesNotExist(name)
}

// MapUint32 获取map[string]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapUint32(name K) map[string]uint32 {
	return s.MapUint32D(name, map[string]uint32{})
}

// MapUint32D 获取map[string]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapUint32D(name K, defaultVal map[string]uint32) map[string]uint32 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, uint32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapUint32E 获取map[string]uint32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapUint32E(name K) (map[string]uint32, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, uint32](v)
		if err == nil {
			return val, nil
		}
		return map[string]uint32{}, errMapValToType(name, v, "map[string]uint32")
	}
	return map[string]uint32{}, errMapKeyDoesNotExist(name)
}

// MapInt64 获取map[string]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapInt64(name K) map[string]int64 {
	return s.MapInt64D(name, map[string]int64{})
}

// MapInt64D 获取map[string]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapInt64D(name K, defaultVal map[string]int64) map[string]int64 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, int64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapInt64E 获取map[string]int64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapInt64E(name K) (map[string]int64, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, int64](v)
		if err == nil {
			return val, nil
		}
		return map[string]int64{}, errMapValToType(name, v, "map[string]int64")
	}
	return map[string]int64{}, errMapKeyDoesNotExist(name)
}

// MapUint64 获取map[string]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapUint64(name K) map[string]uint64 {
	return s.MapUint64D(name, map[string]uint64{})
}

// MapUint64D 获取map[string]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapUint64D(name K, defaultVal map[string]uint64) map[string]uint64 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, uint64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapUint64E 获取map[string]uint64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapUint64E(name K) (map[string]uint64, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, uint64](v)
		if err == nil {
			return val, nil
		}
		return map[string]uint64{}, errMapValToType(name, v, "map[string]uint64")
	}
	return map[string]uint64{}, errMapKeyDoesNotExist(name)
}

// MapFloat32 获取map[string]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapFloat32(name K) map[string]float32 {
	return s.MapFloat32D(name, map[string]float32{})
}

// MapFloat32D 获取map[string]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapFloat32D(name K, defaultVal map[string]float32) map[string]float32 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, float32](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapFloat32E 获取map[string]float32类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapFloat32E(name K) (map[string]float32, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, float32](v)
		if err == nil {
			return val, nil
		}
		return map[string]float32{}, errMapValToType(name, v, "map[string]float32")
	}
	return map[string]float32{}, errMapKeyDoesNotExist(name)
}

// MapFloat64 获取map[string]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapFloat64(name K) map[string]float64 {
	return s.MapFloat64D(name, map[string]float64{})
}

// MapFloat64D 获取map[string]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapFloat64D(name K, defaultVal map[string]float64) map[string]float64 {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, float64](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapFloat64E 获取map[string]float64类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapFloat64E(name K) (map[string]float64, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, float64](v)
		if err == nil {
			return val, nil
		}
		return map[string]float64{}, errMapValToType(name, v, "map[string]float64")
	}
	return map[string]float64{}, errMapKeyDoesNotExist(name)
}

// MapTime 获取map[string]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapTime(name K) map[string]time.Time {
	return s.MapTimeD(name, map[string]time.Time{})
}

// MapTimeD 获取map[string]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapTimeD(name K, defaultVal map[string]time.Time) map[string]time.Time {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, time.Time](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapTimeE 获取map[string]time.Time类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapTimeE(name K) (map[string]time.Time, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, time.Time](v)
		if err == nil {
			return val, nil
		}
		return map[string]time.Time{}, errMapValToType(name, v, "map[string]time.Time")
	}
	return map[string]time.Time{}, errMapKeyDoesNotExist(name)
}

// MapTimeDuration 获取map[string]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回空map
func (s *MapAnySync[K]) MapTimeDuration(name K) map[string]time.Duration {
	return s.MapTimeDurationD(name, map[string]time.Duration{})
}

// MapTimeDurationD 获取map[string]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回默认值
func (s *MapAnySync[K]) MapTimeDurationD(name K, defaultVal map[string]time.Duration) map[string]time.Duration {
	if v, ok := s.shardSync(name).get(name); ok {
		if val, err := values.ToMapAsE[string, time.Duration](v); err == nil {
			return val
		}
	}
	return defaultVal
}

// MapTimeDurationE 获取map[string]time.Duration类型键值，如键值存在且能转换为目标类型则返回，否则返回空map和错误信息
func (s *MapAnySync[K]) MapTimeDurationE(name K) (map[string]time.Duration, error) {
	if v, ok := s.shardSync(name).get(name); ok {
		val, err := values.ToMapAsE[string, time.Duration](v)
		if err == nil {
			return val, nil
		}
		return map[string]time.Duration{}, errMapValToType(name, v, "map[string]time.Duration")
	}
	return map[string]time.Duration{}, errMapKeyDoesNotExist(name)
}

// Scan 通过序列化扫描到指定对象
func (m *MapAnySync[K]) Scan(key K, refVal any) error {
	val, ok := m.shardSync(key).get(key)
	if !ok {
		return fmt.Errorf("MapAnySync[%T] Scan(%v,refVal) name does not exist", key, key)
	}
	if refVal == nil {
		return fmt.Errorf("MapAnySync[%T] Scan(%v,refVal) refVal can not a nil pointer", key, key)
	}
	if bytes, err := jsoner.Marshal(val); err != nil {
		return fmt.Errorf("MapAnySync[%T] Scan(%v,refVal) json Marshal error:%s", key, key, err.Error())
	} else if err := jsoner.Unmarshal(bytes, refVal); err != nil {
		return fmt.Errorf("MapAnySync[%T] Scan(%v,refVal) json Unmarshal error:%s", key, key, err.Error())
	} else {
		return nil
	}
}

// Size 获取数据集大小
func (m *MapAnySync[K]) Size() (size int) {
	for _, sd := range m.shards {
		size += sd.size()
	}
	return
}

// Clear 清空所有数据
func (m *MapAnySync[K]) Clear() {
	for _, sd := range m.shards {
		sd.clear()
	}
}

// Collects 取得map[k]v数据集的浅克隆副本  map[K]any
func (m *MapAnySync[K]) Collects() (data map[K]any) {
	data = make(map[K]any)
	for _, sd := range m.shards {
		for key, val := range sd.mapData() {
			data[key] = val
		}
	}
	return data
}

// Keys 取得map键 数据集的键名副本 []K
func (m *MapAnySync[K]) Keys() (data []K) {
	data = make([]K, 0)
	for _, sd := range m.shards {
		if sd.size() == 0 {
			continue
		}
		data = append(data, sd.keys()...)
	}
	return data
}

// Values 取得map值 数据集的浅克隆副本 []any
func (m *MapAnySync[K]) Values() (data []any) {
	data = make([]any, 0)
	for _, sd := range m.shards {
		if sd.size() == 0 {
			continue
		}
		data = append(data, sd.values()...)
	}
	return data
}

// Iter mak[K]V 元素迭代器
//   - for k,v:=range s.Iter(){}
//   - 注意：迭代顺序不固定, 依据Shard分片+Map[K]V顺序进行迭代
func (m *MapAnySync[K]) Iter() iter.Seq2[K, any] {
	return func(yield func(key K, val any) bool) {
		for _, sd := range m.shards {
			if sd.size() == 0 {
				continue
			}
			for k, v := range sd.mapData() {
				if !yield(k, v) {
					return
				}
			}
		}
	}
}

// IterKeys map[K]V key迭代器
//   - for key:=range s.IterKeys(){}
func (m *MapAnySync[K]) IterKeys() iter.Seq[K] {
	return func(yield func(key K) bool) {
		for _, sd := range m.shards {
			if sd.size() == 0 {
				continue
			}
			for k := range sd.mapData() {
				if !yield(k) {
					return
				}
			}
		}
	}
}

// IterValues map[K]V value 迭代器
//   - for val:=range s.IterValues(){}
func (m *MapAnySync[K]) IterValues() iter.Seq[any] {
	return func(yield func(val any) bool) {
		for _, sd := range m.shards {
			if sd.size() == 0 {
				continue
			}
			for _, v := range sd.mapData() {
				if !yield(v) {
					return
				}
			}
		}
	}
}

// MarshalJSON 序列化集合接口
func (m *MapAnySync[K]) MarshalJSON() ([]byte, error) {
	items := make(map[K]any)
	for _, sd := range m.shards {
		for key, val := range sd.mapData() {
			items[key] = val
		}
	}
	return jsoner.Marshal(items)
}

// UnmarshalJSON 反序列化集合接口
func (m *MapAnySync[K]) UnmarshalJSON(data []byte) error {
	items := make(map[K]any)
	err := jsoner.Unmarshal(data, &items)
	if err != nil {
		return err
	}
	m.Clear()
	for key, val := range items {
		m.shardSync(key).set(key, val)
	}
	return nil
}

// mapSyncShard 对象驱动
// set 设置Shard map k/v 键值
func (m *mapSyncShard[K]) set(key K, val any) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.data[key] = val
}

// delete 删除Shard map值
func (m *mapSyncShard[K]) delete(key K) {
	m.mu.Lock()
	defer m.mu.Unlock()
	delete(m.data, key)
}

// clear 清空Shard map数据
func (m *mapSyncShard[K]) clear() {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.data = make(map[K]any)
}

// has 判断Shard map是否存在key
func (m *mapSyncShard[K]) has(key K) bool {
	m.mu.RLock()
	defer m.mu.RUnlock()
	if _, ok := m.data[key]; ok {
		return true
	}
	return false
}

// get 取得Shard map值
func (m *mapSyncShard[K]) get(key K) (val any, ok bool) {
	m.mu.RLock()
	defer m.mu.RUnlock()
	val, ok = m.data[key]
	return
}

// size 取得Shard map长度
func (m *mapSyncShard[K]) size() int {
	m.mu.RLock()
	defer m.mu.RUnlock()
	return len(m.data)
}

// mapData 取得Shard map原始数据
func (m *mapSyncShard[K]) mapData() map[K]any {
	m.mu.RLock()
	defer m.mu.RUnlock()
	return m.data
}

// keys 取得Shard map键数据集的键名副本 []K
func (m *mapSyncShard[K]) keys() (keys []K) {
	m.mu.RLock()
	defer m.mu.RUnlock()
	keys = make([]K, len(m.data))
	i := 0
	for key := range m.data {
		keys[i] = key
		i++
	}
	return keys
}

// values 取得Shard map值数据集的浅克隆副本 []any
func (m *mapSyncShard[K]) values() (values []any) {
	m.mu.RLock()
	defer m.mu.RUnlock()
	values = make([]any, len(m.data))
	i := 0
	for key := range m.data {
		values[i] = m.data[key]
		i++
	}
	return values
}
